package web_api

import (
	"context"
	"crypto/md5"
	"fmt"
	"io"
	"math"
	"net/http"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"

	"gitee.com/rw555/fdsmastergo/pkg/audioplayer"
	"gitee.com/rw555/fdsmastergo/pkg/audioplayer/factory"
	"gitee.com/rw555/fdsmastergo/pkg/audioplayer/playlist"
	"gitee.com/rw555/fdsmastergo/pkg/logger"
)

// PlaybackStatus 播放状态
type PlaybackStatus struct {
	Status      string  `json:"status"`      // playing, paused, stopped
	CurrentFile string  `json:"currentFile"` // 当前播放文件名
	CurrentTime int     `json:"currentTime"` // 当前播放时间（秒）
	Duration    int     `json:"duration"`    // 总时长（秒）
	Progress    float64 `json:"progress"`    // 播放进度（百分比）
	Storage     struct {
		Total     int64 `json:"total"`     // 总容量（字节）
		Used      int64 `json:"used"`      // 已用空间（字节）
		Available int64 `json:"available"` // 可用空间（字节）
	} `json:"storage"`
}

// 音频文件信息
type AudioFile struct {
	Name     string    `json:"name"`     // 文件名
	Size     int64     `json:"size"`     // 文件大小（字节）
	Modified time.Time `json:"modified"` // 修改时间
	MD5      string    `json:"md5"`      // MD5校验值
}

// AudioManager 音频管理器
type AudioManager struct {
	sync.RWMutex
	audioConfig     *audioplayer.Config
	audioPlayer     audioplayer.AudioPlayer      // 音频播放器接口
	clients         map[chan PlaybackStatus]bool // SSE客户端列表
	audioPath       string                       // 音频文件存储路径
	maxStorageSize  int64                        // 最大存储空间
	files           map[string]AudioFile         // 音频文件信息缓存
	SystemConfig    map[string]interface{}
	stopChan        chan struct{}            // 停止通道，用于关闭定时器协程
	playlistManager playlist.PlaylistManager // 播放列表管理器
}

// NewAudioManager 创建新的音频管理器
func NewAudioManager(systemConfig map[string]interface{}, basePath string) (*AudioManager, error) {
	// 构建音频目录的完整路径
	maxStorageSize := 1024 * 1024 * int64(systemConfig["webserver.music.max_storage_size"].(float64))
	audioDirName := systemConfig["webserver.music.base_path"].(string)
	audioPath := filepath.Join(basePath, audioDirName)
	logger.SystemInfo("音频文件存储路径",
		zap.String("basePath", basePath),
		zap.String("audioPath", audioPath),
		zap.Int64("maxStorageSize", maxStorageSize),
	)

	// 确保音频目录存在
	if err := os.MkdirAll(audioPath, 0755); err != nil {
		return nil, fmt.Errorf("创建音频目录失败: %w", err)
	}

	am := &AudioManager{
		clients:        make(map[chan PlaybackStatus]bool),
		audioPath:      audioPath,
		files:          make(map[string]AudioFile),
		SystemConfig:   systemConfig,
		maxStorageSize: maxStorageSize,
		stopChan:       make(chan struct{}), // 初始化停止通道
	}

	// 创建音频播放器
	audioCfg := audioplayer.NewDefaultConfig()
	audioCfg.AdapterType = audioplayer.AdapterMpg123
	audioCfg.PreferredFormat = audioplayer.FormatMP3
	audioCfg.AudioPath = audioPath
	audioCfg.AutoPlayNext = false
	audioPlayer, err := factory.CreateAudioPlayer(audioCfg)
	if err != nil {
		logger.SystemWarn("创建音频播放器失败，使用虚拟播放器", zap.Error(err))
		return nil, err
	}
	am.audioConfig = audioCfg
	am.audioPlayer = audioPlayer

	// 创建播放列表目录
	playlistsDir := filepath.Join(audioPath, "playlists")
	if err := os.MkdirAll(playlistsDir, 0755); err != nil {
		logger.SystemWarn("创建播放列表目录失败", zap.Error(err), zap.String("path", playlistsDir))
	} else {
		logger.SystemInfo("播放列表目录", zap.String("path", playlistsDir))
	}

	// 初始化播放列表管理器
	playlistManager, err := playlist.NewPlaylistManager(playlistsDir, am.audioPlayer)
	if err != nil {
		logger.SystemWarn("初始化播放列表管理器失败", zap.Error(err))
	} else {
		am.playlistManager = playlistManager
		// 加载播放列表
		if err := playlistManager.LoadPlaylists(); err != nil {
			logger.SystemWarn("加载播放列表失败", zap.Error(err))
		}
	}

	// 注册播放事件处理器
	am.registerEventHandlers()

	// 扫描音频目录
	if err := am.scanAudioDirectory(); err != nil {
		logger.SystemWarn("扫描音频目录失败", zap.Error(err))
	}

	return am, nil
}

// registerEventHandlers 注册播放事件处理器
func (am *AudioManager) registerEventHandlers() {
	// 播放开始事件
	am.audioPlayer.RegisterEventHandler(audioplayer.EventPlaybackStarted, func(event audioplayer.PlaybackEvent) {
		if event.Info.Source != nil {
			logger.SystemInfo("开始播放",
				zap.String("file", event.Info.Source.Name),
				zap.Float64("duration", event.Info.Duration))

			// 通知所有客户端
			am.broadcastStatus()
		}
	})

	// 播放完成事件
	am.audioPlayer.RegisterEventHandler(audioplayer.EventPlaybackCompleted, func(event audioplayer.PlaybackEvent) {
		logger.SystemInfo("播放完成")

		// 通知所有客户端
		am.broadcastStatus()
	})

	// 播放暂停事件
	am.audioPlayer.RegisterEventHandler(audioplayer.EventPlaybackPaused, func(event audioplayer.PlaybackEvent) {
		logger.SystemDebug("播放暂停")

		// 通知所有客户端
		am.broadcastStatus()
	})

	// 播放恢复事件
	am.audioPlayer.RegisterEventHandler(audioplayer.EventPlaybackResumed, func(event audioplayer.PlaybackEvent) {
		logger.SystemDebug("播放恢复")

		// 通知所有客户端
		am.broadcastStatus()
	})

	// 播放停止事件
	am.audioPlayer.RegisterEventHandler(audioplayer.EventPlaybackStopped, func(event audioplayer.PlaybackEvent) {
		logger.SystemDebug("播放停止")

		// 通知所有客户端
		am.broadcastStatus()
	})

	// 播放错误事件
	am.audioPlayer.RegisterEventHandler(audioplayer.EventPlaybackError, func(event audioplayer.PlaybackEvent) {
		logger.SystemError("播放错误",
			zap.String("error", event.Info.Error))

		// 通知所有客户端
		am.broadcastStatus()
	})

	// 播放位置变更事件
	var lastUpdatePosition float64 = 0
	var lastUpdateTime time.Time = time.Now()

	const minUpdateInterval = 500 * time.Millisecond // 至少500毫秒才发送一次更新
	const positionChangeThreshold = 0.5              // 位置变化至少0.5秒才发送更新

	am.audioPlayer.RegisterEventHandler(audioplayer.EventPositionChanged, func(event audioplayer.PlaybackEvent) {
		// 获取当前位置
		position := event.Info.Position

		// 计算位置变化量
		positionDiff := math.Abs(position - lastUpdatePosition)

		// 计算距离上次更新的时间
		now := time.Now()
		timeDiff := now.Sub(lastUpdateTime)

		// 只有在位置变化超过阈值且间隔时间足够长时才更新
		if positionDiff >= positionChangeThreshold && timeDiff >= minUpdateInterval {
			// 更新记录值
			lastUpdatePosition = position
			lastUpdateTime = now

			// 通知所有客户端
			am.broadcastStatus()
		}
	})
}

// broadcastStatus 广播当前状态给所有客户端
func (am *AudioManager) broadcastStatus() {
	am.RLock()

	// 获取当前状态
	status := am.getPlaybackStatus()

	// 获取客户端列表副本
	clients := make([]chan PlaybackStatus, 0, len(am.clients))
	for client := range am.clients {
		clients = append(clients, client)
	}

	am.RUnlock()

	// 广播状态给所有客户端，不持有锁
	for _, client := range clients {
		select {
		case client <- status:
			// 状态发送成功
		default:
			// 客户端无响应，稍后移除
			logger.SystemWarn("客户端无响应，准备移除连接")
			go func(ch chan PlaybackStatus) {
				am.Lock()
				delete(am.clients, ch)
				close(ch)
				am.Unlock()
			}(client)
		}
	}
}

// getPlaybackStatus 根据当前播放信息生成PlaybackStatus
func (am *AudioManager) getPlaybackStatus() PlaybackStatus {
	// 获取存储信息
	used, err := am.calculateStorageUsage()
	if err != nil {
		logger.SystemError("计算存储空间失败", zap.Error(err))
		used = 0
	}

	// 获取当前播放信息
	playbackInfo := am.audioPlayer.GetPlaybackInfo()

	// 确保状态是字符串类型
	statusStr := string(playbackInfo.Status)
	logger.SystemDebug("获取状态字符串",
		zap.String("rawStatus", string(playbackInfo.Status)),
		zap.String("statusStr", statusStr))

	// 创建状态对象
	status := PlaybackStatus{
		Status: statusStr,
		Storage: struct {
			Total     int64 `json:"total"`
			Used      int64 `json:"used"`
			Available int64 `json:"available"`
		}{
			Total:     am.maxStorageSize,
			Used:      used,
			Available: am.maxStorageSize - used,
		},
	}

	// 如果有正在播放的文件，填充文件信息
	if playbackInfo.Source != nil {
		if status.Status == "stopped" {
			status.CurrentFile = ""
		} else {
			status.CurrentFile = playbackInfo.Source.Name
		}

		// 确保时间数据有效性
		position := playbackInfo.Position
		duration := playbackInfo.Duration

		// 检查时长数据
		if duration <= 0 {
			logger.SystemWarn("检测到无效的音频总时长",
				zap.Float64("rawDuration", duration),
				zap.String("file", status.CurrentFile))
			// 使用一个合理的默认值
			duration = 100.0
		}

		// 确保当前位置不超过总时长
		if position > duration {
			logger.SystemWarn("当前位置超过总时长，进行修正",
				zap.Float64("rawPosition", position),
				zap.Float64("duration", duration))
			position = duration
		}

		// 设置int类型的时间数据
		status.CurrentTime = int(position)
		status.Duration = int(duration)

		// 计算进度并限制在0-100范围内
		if duration > 0 {
			status.Progress = (position / duration) * 100
			// 确保进度百分比在有效范围内
			if status.Progress > 100 {
				logger.SystemWarn("进度超过100%，修正为100%",
					zap.Float64("rawProgress", status.Progress),
					zap.Float64("position", position),
					zap.Float64("duration", duration))
				status.Progress = 100
			} else if status.Progress < 0 {
				logger.SystemWarn("进度小于0%，修正为0%",
					zap.Float64("rawProgress", status.Progress))
				status.Progress = 0
			}
		} else {
			status.Progress = 0
		}

		logger.SystemDebug("文件播放信息",
			zap.String("file", status.CurrentFile),
			zap.Int("currentTime", status.CurrentTime),
			zap.Int("duration", status.Duration),
			zap.Float64("progress", status.Progress))
	} else {
		logger.SystemDebug("无播放文件")
	}

	// 添加更详细的日志
	logger.SystemDebug("生成播放状态信息",
		zap.String("statusRaw", string(playbackInfo.Status)),
		zap.String("statusStr", status.Status),
		zap.String("file", status.CurrentFile),
		zap.Float64("position", playbackInfo.Position),
		zap.Float64("duration", playbackInfo.Duration),
		zap.Float64("progress", status.Progress))

	return status
}

// Close 关闭音频管理器
func (am *AudioManager) Close() {
	am.Lock()
	defer am.Unlock()

	// 发送停止信号给定时器协程
	logger.SystemInfo("正在停止音频状态更新协程...")
	select {
	case am.stopChan <- struct{}{}:
		// 成功发送停止信号
	default:
		// 通道已关闭或已满，忽略
	}
	close(am.stopChan)

	// 保存播放列表
	if am.playlistManager != nil {
		logger.SystemInfo("正在保存播放列表...")
		if err := am.playlistManager.SavePlaylists(); err != nil {
			logger.SystemError("保存播放列表失败", zap.Error(err))
		} else {
			logger.SystemInfo("播放列表已保存")
		}
	}

	// 安全关闭所有客户端通道
	logger.SystemInfo("正在关闭所有SSE客户端连接...", zap.Int("连接数", len(am.clients)))

	// 创建客户端通道的副本，用于遍历，避免在遍历时修改map
	clientChannels := make([]chan PlaybackStatus, 0, len(am.clients))
	for client := range am.clients {
		clientChannels = append(clientChannels, client)
	}

	// 清空客户端映射
	am.clients = make(map[chan PlaybackStatus]bool)

	// 逐个安全关闭通道，使用defer-recover防止panic
	for _, client := range clientChannels {
		func(ch chan PlaybackStatus) {
			defer func() {
				if r := recover(); r != nil {
					logger.SystemWarn("关闭客户端通道时发生panic", zap.Any("error", r))
				}
			}()
			// 尝试向通道发送停止状态
			stopStatus := PlaybackStatus{
				Status: "stopped",
				Storage: struct {
					Total     int64 `json:"total"`
					Used      int64 `json:"used"`
					Available int64 `json:"available"`
				}{
					Total:     am.maxStorageSize,
					Used:      0,
					Available: am.maxStorageSize,
				},
			}
			select {
			case ch <- stopStatus:
				// 成功发送停止状态
			default:
				// 通道已满或已关闭，忽略
			}
			close(ch)
		}(client)
	}

	// 关闭音频播放器
	if am.audioPlayer != nil {
		logger.SystemInfo("正在关闭音频播放器...")
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
		defer cancel()

		// 尝试先停止播放
		if am.audioPlayer.IsPlaying() {
			if err := am.audioPlayer.Stop(ctx); err != nil {
				logger.SystemWarn("停止音频播放失败", zap.Error(err))
			}
		}

		// 关闭播放器
		if err := am.audioPlayer.Close(); err != nil {
			logger.SystemError("关闭音频播放器失败", zap.Error(err))
		}
	}

	logger.SystemInfo("音频管理器已关闭")
}

// HandleStreamEvents 处理SSE流事件
func (h *Handler) HandleStreamEvents(c *gin.Context) {
	// 设置SSE响应头
	c.Writer.Header().Set("Content-Type", "text/event-stream")
	c.Writer.Header().Set("Cache-Control", "no-cache")
	c.Writer.Header().Set("Connection", "keep-alive")
	c.Writer.Header().Set("Access-Control-Allow-Origin", "*")

	// 创建事件通道，设置合理的缓冲区大小
	events := make(chan PlaybackStatus, 10)

	// 创建一个终止信号通道
	termSignal := make(chan struct{})

	// 注册客户端
	h.AudioManager.Lock()
	h.AudioManager.clients[events] = true
	h.AudioManager.Unlock()

	// 发送初始状态
	initialStatus := h.AudioManager.getPlaybackStatus()
	c.SSEvent("message", initialStatus)
	c.Writer.Flush()

	// 设置客户端关闭通知
	notify := c.Request.Context().Done()

	// 处理客户端断开连接
	go func() {
		defer func() {
			// 防止panic: close of closed channel
			if r := recover(); r != nil {
				logger.SystemWarn("清理SSE连接时发生panic", zap.Any("error", r))
			}

			// 发送终止信号
			close(termSignal)
		}()

		<-notify

		// 客户端断开连接
		h.AudioManager.Lock()
		// 只有当客户端仍在列表中时才关闭和删除
		if _, exists := h.AudioManager.clients[events]; exists {
			delete(h.AudioManager.clients, events)

			// 客户端断开连接时，检查是否是最后一个客户端
			if len(h.AudioManager.clients) == 0 {
				// 如果是最后一个客户端，停止当前播放
				playbackInfo := h.AudioManager.audioPlayer.GetPlaybackInfo()
				if playbackInfo.Status == audioplayer.StatusPlaying || playbackInfo.Status == audioplayer.StatusPaused {
					// 解锁避免死锁（因为Stop方法可能会获取锁）
					h.AudioManager.Unlock()

					logger.SystemInfo("所有客户端断开连接，自动停止音频播放")
					// 使用上下文停止播放
					ctx := context.Background()
					err := h.AudioManager.audioPlayer.Stop(ctx)
					if err != nil {
						logger.SystemError("自动停止播放失败", zap.Error(err))
					}

					// 重新获取锁以继续执行下面的代码
					h.AudioManager.Lock()
				}
			}

			// 安全关闭通道
			defer func() {
				if r := recover(); r != nil {
					logger.SystemWarn("关闭events通道时发生panic", zap.Any("error", r))
				}
			}()

			// 尝试关闭通道
			close(events)
		}
		h.AudioManager.Unlock()
	}()

	// 发送事件循环 - 添加超时机制
	eventLoopDone := make(chan struct{})
	go func() {
		defer close(eventLoopDone)

		for status := range events {
			// 检查写入是否会阻塞
			select {
			case <-notify:
				logger.SystemInfo("客户端已断开，停止发送事件")
				return
			default:
				// 继续处理
			}

			logger.SystemInfo("发送事件", zap.Any("status", status))
			c.SSEvent("message", status)
			c.Writer.Flush()
		}
	}()

	// 等待事件循环结束或超时
	select {
	case <-eventLoopDone:
		logger.SystemInfo("SSE事件循环正常结束")
	case <-termSignal:
		logger.SystemInfo("SSE连接被终止")
	}
}

// HandleMusicControl 控制音频播放
func (h *Handler) HandleMusicControl(c *gin.Context) {
	action := c.Query("action")
	if action == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定操作",
		})
		return
	}

	logger.SystemInfo("控制音频播放", zap.String("action", action))

	switch action {
	case "play":
		filename := c.Query("filename")
		if filename == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "未指定文件名",
			})
			return
		}

		// 检查文件是否存在
		h.AudioManager.Lock()
		audioFile, exists := h.AudioManager.files[filename]
		h.AudioManager.Unlock()

		if !exists {
			c.JSON(http.StatusNotFound, gin.H{
				"success": false,
				"error":   "文件不存在",
			})
			return
		}

		// 创建音频源对象
		audioSource := audioplayer.AudioSource{
			Path:   filepath.Join(h.AudioManager.audioPath, filename),
			Format: getAudioFormatFromFilename(filename),
			Name:   audioFile.Name,
		}

		// 使用AudioPlayer播放音频
		ctx := context.Background()
		err := h.AudioManager.audioPlayer.Play(ctx, audioSource)
		if err != nil {
			logger.SystemError("播放音频失败",
				zap.String("filename", filename),
				zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("播放失败: %v", err),
			})
			return
		}

	case "pause":
		// 使用AudioPlayer暂停音频
		ctx := context.Background()
		if err := h.AudioManager.audioPlayer.Pause(ctx); err != nil {
			logger.SystemError("暂停音频失败", zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("暂停失败: %v", err),
			})
			return
		}

		logger.SystemInfo("暂停播放文件")

	case "resume":
		// 使用AudioPlayer恢复播放
		ctx := context.Background()

		// 获取filename参数
		filename := c.Query("filename")

		// 检查播放状态
		playbackInfo := h.AudioManager.audioPlayer.GetPlaybackInfo()

		logger.SystemInfo("处理恢复播放请求",
			zap.String("status", string(playbackInfo.Status)),
			zap.String("filename", filename))

		// 如果是暂停状态，正常恢复播放
		if playbackInfo.Status == audioplayer.StatusPaused {
			if err := h.AudioManager.audioPlayer.Resume(ctx); err != nil {
				logger.SystemError("恢复播放失败", zap.Error(err))
				c.JSON(http.StatusInternalServerError, gin.H{
					"success": false,
					"error":   fmt.Sprintf("恢复播放失败: %v", err),
				})
				return
			}

			logger.SystemInfo("恢复暂停的播放")
			c.JSON(http.StatusOK, gin.H{
				"success": true,
			})
			return
		}

		// 如果是停止状态但上次播放过此文件，尝试从上次位置继续播放
		if playbackInfo.Status == audioplayer.StatusStopped && playbackInfo.Position > 0 && filename != "" {
			logger.SystemInfo("从停止状态恢复播放，尝试从上次位置继续",
				zap.String("filename", filename),
				zap.Float64("position", playbackInfo.Position))

			// 检查文件是否存在
			h.AudioManager.Lock()
			audioFile, exists := h.AudioManager.files[filename]
			h.AudioManager.Unlock()

			if !exists {
				c.JSON(http.StatusNotFound, gin.H{
					"success": false,
					"error":   "文件不存在",
				})
				return
			}

			// 创建音频源对象
			audioSource := audioplayer.AudioSource{
				Path:   filepath.Join(h.AudioManager.audioPath, filename),
				Format: getAudioFormatFromFilename(filename),
				Name:   audioFile.Name,
			}

			// 使用AudioPlayer播放音频
			err := h.AudioManager.audioPlayer.Play(ctx, audioSource)
			if err != nil {
				logger.SystemError("播放音频失败",
					zap.String("filename", filename),
					zap.Error(err))
				c.JSON(http.StatusInternalServerError, gin.H{
					"success": false,
					"error":   fmt.Sprintf("播放失败: %v", err),
				})
				return
			}

			// 如果上次位置是靠近结尾（大于95%的进度），则从头开始播放
			if playbackInfo.Position > 0 && playbackInfo.Duration > 0 &&
				playbackInfo.Position/playbackInfo.Duration < 0.95 {

				// 尝试跳转到上次播放的位置
				err = h.AudioManager.audioPlayer.Seek(ctx, playbackInfo.Position)
				if err != nil {
					logger.SystemWarn("跳转到上次播放位置失败，从头开始播放",
						zap.Float64("position", playbackInfo.Position),
						zap.Error(err))
				} else {
					logger.SystemInfo("成功跳转到上次播放位置",
						zap.Float64("position", playbackInfo.Position))
				}
			} else {
				logger.SystemInfo("上次播放接近结束或无效，从头开始播放")
			}

			c.JSON(http.StatusOK, gin.H{
				"success": true,
			})
			return
		}

		// 如果不是暂停状态，但请求中包含文件名，且没有有效的上次播放位置，则当作play操作处理，从头播放
		if filename != "" {
			logger.SystemInfo("非暂停状态收到resume请求，无有效播放位置，视为从头播放",
				zap.String("filename", filename))

			// 检查文件是否存在
			h.AudioManager.Lock()
			audioFile, exists := h.AudioManager.files[filename]
			h.AudioManager.Unlock()

			if !exists {
				c.JSON(http.StatusNotFound, gin.H{
					"success": false,
					"error":   "文件不存在",
				})
				return
			}

			// 创建音频源对象
			audioSource := audioplayer.AudioSource{
				Path:   filepath.Join(h.AudioManager.audioPath, filename),
				Format: getAudioFormatFromFilename(filename),
				Name:   audioFile.Name,
			}

			// 使用AudioPlayer播放音频
			err := h.AudioManager.audioPlayer.Play(ctx, audioSource)
			if err != nil {
				logger.SystemError("播放音频失败",
					zap.String("filename", filename),
					zap.Error(err))
				c.JSON(http.StatusInternalServerError, gin.H{
					"success": false,
					"error":   fmt.Sprintf("播放失败: %v", err),
				})
				return
			}

			c.JSON(http.StatusOK, gin.H{
				"success": true,
			})
			return
		}

		// 如果既不是暂停状态，也没有指定文件名，返回错误
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无法恢复播放：没有暂停的音频且未指定文件名",
		})

	case "stop":
		// 使用AudioPlayer停止播放
		ctx := context.Background()
		if err := h.AudioManager.audioPlayer.Stop(ctx); err != nil {
			logger.SystemError("停止播放失败", zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("停止播放失败: %v", err),
			})
			return
		}

		logger.SystemInfo("停止播放文件")

	case "playlist":
		// 获取播放列表
		playlist, err := h.AudioManager.audioPlayer.GetPlaylist()
		if err != nil {
			logger.SystemError("获取播放列表失败", zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("获取播放列表失败: %v", err),
			})
			return
		}

		c.JSON(http.StatusOK, gin.H{
			"success":  true,
			"playlist": playlist,
		})
		return

	case "next":
		// 播放下一首
		ctx := context.Background()
		if err := h.AudioManager.audioPlayer.PlayNext(ctx); err != nil {
			logger.SystemError("播放下一首失败", zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("播放下一首失败: %v", err),
			})
			return
		}

		logger.SystemInfo("播放下一首")

	case "previous":
		// 播放上一首
		ctx := context.Background()
		if err := h.AudioManager.audioPlayer.PlayPrevious(ctx); err != nil {
			logger.SystemError("播放上一首失败", zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("播放上一首失败: %v", err),
			})
			return
		}

		logger.SystemInfo("播放上一首")

	case "seek":
		// 跳转到指定位置
		positionStr := c.Query("position")
		if positionStr == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "未指定播放位置",
			})
			return
		}

		position, err := strconv.ParseFloat(positionStr, 64)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "播放位置格式无效",
			})
			return
		}

		ctx := context.Background()
		if err := h.AudioManager.audioPlayer.Seek(ctx, position); err != nil {
			logger.SystemError("跳转播放位置失败",
				zap.Float64("position", position),
				zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("跳转播放位置失败: %v", err),
			})
			return
		}

		logger.SystemInfo("跳转播放位置", zap.Float64("position", position))

	case "volume":
		// 设置音量
		volumeStr := c.Query("volume")
		if volumeStr == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "未指定音量",
			})
			return
		}

		volume, err := strconv.ParseFloat(volumeStr, 64)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "音量格式无效",
			})
			return
		}

		if err := h.AudioManager.audioPlayer.SetVolume(volume); err != nil {
			logger.SystemError("设置音量失败",
				zap.Float64("volume", volume),
				zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("设置音量失败: %v", err),
			})
			return
		}

		logger.SystemInfo("设置音量", zap.Float64("volume", volume))

	case "addtoplaylist":
		// 添加到播放列表
		filename := c.Query("filename")
		if filename == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "未指定文件名",
			})
			return
		}

		// 检查文件是否存在
		h.AudioManager.Lock()
		audioFile, exists := h.AudioManager.files[filename]
		h.AudioManager.Unlock()

		if !exists {
			c.JSON(http.StatusNotFound, gin.H{
				"success": false,
				"error":   "文件不存在",
			})
			return
		}

		// 创建音频源对象
		audioSource := audioplayer.AudioSource{
			Path:   filepath.Join(h.AudioManager.audioPath, filename),
			Format: getAudioFormatFromFilename(filename),
			Name:   audioFile.Name,
		}

		// 添加到播放列表
		if err := h.AudioManager.audioPlayer.AddToPlaylist(audioSource); err != nil {
			logger.SystemError("添加到播放列表失败",
				zap.String("filename", filename),
				zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("添加到播放列表失败: %v", err),
			})
			return
		}

		logger.SystemInfo("添加到播放列表", zap.String("filename", filename))

	case "removefromplaylist":
		// 从播放列表移除
		indexStr := c.Query("index")
		if indexStr == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "未指定索引",
			})
			return
		}

		index, err := strconv.Atoi(indexStr)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "索引格式无效",
			})
			return
		}

		if err := h.AudioManager.audioPlayer.RemoveFromPlaylist(index); err != nil {
			logger.SystemError("从播放列表移除失败",
				zap.Int("index", index),
				zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("从播放列表移除失败: %v", err),
			})
			return
		}

		logger.SystemInfo("从播放列表移除", zap.Int("index", index))

	case "clearplaylist":
		// 清空播放列表
		if err := h.AudioManager.audioPlayer.ClearPlaylist(); err != nil {
			logger.SystemError("清空播放列表失败", zap.Error(err))
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("清空播放列表失败: %v", err),
			})
			return
		}

		logger.SystemInfo("清空播放列表")

	default:
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "不支持的操作",
		})
		return
	}

	// 获取当前状态作为响应
	status := h.AudioManager.getPlaybackStatus()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "操作成功",
		"status":  status,
	})
}

// scanAudioDirectory 扫描音频目录并加载文件信息
func (am *AudioManager) scanAudioDirectory() error {
	am.Lock()
	defer am.Unlock()

	// 清空现有文件列表
	am.files = make(map[string]AudioFile)

	// 扫描目录
	files, err := os.ReadDir(am.audioPath)
	if err != nil {
		return fmt.Errorf("扫描音频目录失败: %w", err)
	}

	// 处理每个文件
	for _, file := range files {
		if file.IsDir() {
			continue
		}

		filename := file.Name()
		filePath := filepath.Join(am.audioPath, filename)

		// 获取文件信息
		fileInfo, err := os.Stat(filePath)
		if err != nil {
			logger.SystemError("获取文件信息失败",
				zap.String("filename", filename),
				zap.Error(err))
			continue
		}

		// 计算MD5
		md5sum, err := calculateFileMD5(filePath)
		if err != nil {
			logger.SystemError("计算文件MD5失败",
				zap.String("filename", filename),
				zap.Error(err))
			continue
		}

		// 添加到文件列表
		am.files[filename] = AudioFile{
			Name:     filename,
			Size:     fileInfo.Size(),
			Modified: fileInfo.ModTime(),
			MD5:      md5sum,
		}
	}

	logger.SystemInfo("扫描音频目录完成",
		zap.Int("fileCount", len(am.files)))
	return nil
}

// calculateStorageUsage 计算已用存储空间
func (am *AudioManager) calculateStorageUsage() (int64, error) {
	var used int64
	err := filepath.Walk(am.audioPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			used += info.Size()
		}
		return nil
	})
	if err != nil {
		return 0, fmt.Errorf("计算存储空间失败: %w", err)
	}
	return used, nil
}

// 辅助函数：计算文件MD5
func calculateFileMD5(filePath string) (string, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return "", err
	}
	defer file.Close()

	hash := md5.New()
	if _, err := io.Copy(hash, file); err != nil {
		return "", err
	}

	return fmt.Sprintf("%x", hash.Sum(nil)), nil
}

// getAudioFormatFromFilename 根据文件名获取音频格式
func getAudioFormatFromFilename(filename string) audioplayer.AudioFormat {
	ext := strings.ToLower(filepath.Ext(filename))
	switch ext {
	case ".wav":
		return audioplayer.FormatWAV
	case ".mp3":
		return audioplayer.FormatMP3
	case ".flac":
		return audioplayer.FormatFLAC
	case ".ogg":
		return audioplayer.FormatOGG
	default:
		return audioplayer.FormatWAV // 默认为WAV格式
	}
}

// HandleMusicUpload 处理音频文件上传
func (h *Handler) HandleMusicUpload(c *gin.Context) {
	// 获取上传的文件
	form, err := c.MultipartForm()
	if err != nil {
		logger.SystemError("解析上传表单失败", zap.Error(err))
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无效的上传请求",
		})
		return
	}

	files := form.File["files[]"]
	if len(files) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "没有选择文件",
		})
		return
	}

	// 获取音频管理器信息
	h.AudioManager.RLock()
	audioPath := h.AudioManager.audioPath
	maxStorageSize := h.AudioManager.maxStorageSize
	h.AudioManager.RUnlock()

	// 检查存储空间
	used, err := h.AudioManager.calculateStorageUsage()
	if err != nil {
		logger.SystemError("计算存储空间失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "计算存储空间失败",
		})
		return
	}

	// 计算上传文件的总大小
	var totalSize int64
	for _, file := range files {
		totalSize += file.Size
	}

	// 检查是否超出存储限制
	if used+totalSize > maxStorageSize {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "存储空间不足",
		})
		return
	}

	// 处理每个文件
	successCount := 0
	for _, file := range files {
		// 保存文件
		dst := filepath.Join(audioPath, file.Filename)
		if err := c.SaveUploadedFile(file, dst); err != nil {
			logger.SystemError("保存文件失败",
				zap.String("filename", file.Filename),
				zap.Error(err))
			continue
		}

		// 获取文件信息
		fileInfo, err := os.Stat(dst)
		if err != nil {
			logger.SystemError("获取文件信息失败",
				zap.String("filename", file.Filename),
				zap.Error(err))
			continue
		}

		// 计算MD5
		md5sum, err := calculateFileMD5(dst)
		if err != nil {
			logger.SystemError("计算文件MD5失败",
				zap.String("filename", file.Filename),
				zap.Error(err))
			continue
		}

		// 更新文件信息缓存
		h.AudioManager.Lock()
		h.AudioManager.files[file.Filename] = AudioFile{
			Name:     file.Filename,
			Size:     fileInfo.Size(),
			Modified: fileInfo.ModTime(),
			MD5:      md5sum,
		}
		h.AudioManager.Unlock()

		successCount++
		logger.SystemInfo("文件上传成功",
			zap.String("filename", file.Filename),
			zap.Int64("size", fileInfo.Size()),
			zap.String("md5", md5sum))
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": fmt.Sprintf("上传成功 %d 个文件", successCount),
		"count":   successCount,
	})
}

// HandleMusicList 获取音频文件列表
func (h *Handler) HandleMusicList(c *gin.Context) {
	h.AudioManager.RLock()
	audioPath := h.AudioManager.audioPath
	files := make([]AudioFile, 0, len(h.AudioManager.files))
	for _, file := range h.AudioManager.files {
		files = append(files, file)
	}
	h.AudioManager.RUnlock()

	// 获取存储信息
	used, err := h.AudioManager.calculateStorageUsage()
	if err != nil {
		logger.SystemError("计算存储空间失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "计算存储空间失败",
		})
		return
	}

	c.Header("Content-Type", "application/json")
	c.Header("Cache-Control", "no-cache, no-store, must-revalidate")
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"path":    audioPath,
		"total":   len(files),
		"files":   files,
		"storage": gin.H{
			"used":      used,
			"total":     h.AudioManager.maxStorageSize,
			"available": h.AudioManager.maxStorageSize - used,
		},
	})
}

// HandleMusicDelete 处理音频文件删除
func (h *Handler) HandleMusicDelete(c *gin.Context) {
	filename := c.Query("filename")
	if filename == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定文件名",
		})
		return
	}

	// 检查是否正在播放此文件
	h.AudioManager.RLock()
	audioPath := h.AudioManager.audioPath
	playbackInfo := h.AudioManager.audioPlayer.GetPlaybackInfo()
	h.AudioManager.RUnlock()

	// 如果文件正在播放，禁止删除
	if playbackInfo.Status == "playing" || playbackInfo.Status == "paused" {
		if playbackInfo.Source != nil && playbackInfo.Source.Name == filename {
			c.JSON(http.StatusBadRequest, gin.H{
				"success": false,
				"error":   "文件正在播放，请先停止播放",
			})
			return
		}
	}

	// 检查文件是否在播放列表中
	playlist, err := h.AudioManager.audioPlayer.GetPlaylist()
	if err == nil {
		for _, item := range playlist {
			if item.Name == filename {
				c.JSON(http.StatusBadRequest, gin.H{
					"success": false,
					"error":   "文件在播放列表中，请先从播放列表移除",
				})
				return
			}
		}
	}

	// 检查文件是否存在
	h.AudioManager.RLock()
	_, exists := h.AudioManager.files[filename]
	h.AudioManager.RUnlock()

	if !exists {
		c.JSON(http.StatusNotFound, gin.H{
			"success": false,
			"error":   "文件不存在",
		})
		return
	}

	// 构建文件路径
	filePath := filepath.Join(audioPath, filename)

	// 删除文件
	if err := os.Remove(filePath); err != nil {
		logger.SystemError("删除文件失败",
			zap.String("filename", filename),
			zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("删除文件失败: %v", err),
		})
		return
	}

	// 从缓存中移除文件信息
	h.AudioManager.Lock()
	delete(h.AudioManager.files, filename)
	h.AudioManager.Unlock()

	logger.SystemInfo("文件删除成功", zap.String("filename", filename))
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "文件删除成功",
	})
}

// HandleMusicDeleteAll 删除所有音频文件
func (h *Handler) HandleMusicDeleteAll(c *gin.Context) {
	// 获取播放信息，检查是否正在播放
	playbackInfo := h.AudioManager.audioPlayer.GetPlaybackInfo()
	if playbackInfo.Status == "playing" || playbackInfo.Status == "paused" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "正在播放音频，请先停止播放",
		})
		return
	}

	// 检查播放列表是否为空
	playlist, err := h.AudioManager.audioPlayer.GetPlaylist()
	if err == nil && len(playlist) > 0 {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "播放列表不为空，请先清空播放列表",
		})
		return
	}

	// 获取音频路径
	h.AudioManager.RLock()
	audioPath := h.AudioManager.audioPath
	files := make([]string, 0, len(h.AudioManager.files))
	for filename := range h.AudioManager.files {
		files = append(files, filename)
	}
	h.AudioManager.RUnlock()

	// 删除所有文件
	deleteCount := 0
	for _, filename := range files {
		filePath := filepath.Join(audioPath, filename)
		if err := os.Remove(filePath); err != nil {
			logger.SystemError("删除文件失败",
				zap.String("filename", filename),
				zap.Error(err))
			continue
		}
		deleteCount++
	}

	// 清空文件缓存
	h.AudioManager.Lock()
	h.AudioManager.files = make(map[string]AudioFile)
	h.AudioManager.Unlock()

	logger.SystemInfo("批量删除文件成功", zap.Int("count", deleteCount))
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": fmt.Sprintf("成功删除 %d 个文件", deleteCount),
		"count":   deleteCount,
	})
}

// HandleMusicStatus 获取音频播放状态
func (h *Handler) HandleMusicStatus(c *gin.Context) {
	// 获取当前播放状态
	status := h.AudioManager.getPlaybackStatus()

	// 获取播放列表
	playlist, err := h.AudioManager.audioPlayer.GetPlaylist()
	playlistItems := make([]map[string]interface{}, 0)

	if err == nil {
		for i, item := range playlist {
			playlistItems = append(playlistItems, map[string]interface{}{
				"index":  i,
				"name":   item.Name,
				"format": item.Format,
				"path":   item.Path,
			})
		}
	}

	// 构建详细的播放状态响应
	playbackInfo := h.AudioManager.audioPlayer.GetPlaybackInfo()
	response := gin.H{
		"success":  true,
		"status":   status.Status,
		"position": playbackInfo.Position,
		"duration": playbackInfo.Duration,
		"volume":   playbackInfo.Volume,
		"storage": gin.H{
			"used":      status.Storage.Used,
			"total":     status.Storage.Total,
			"available": status.Storage.Available,
		},
		"playlist":  playlistItems,
		"isPlaying": playbackInfo.Status == "playing",
		"isPaused":  playbackInfo.Status == "paused",
		"isStopped": playbackInfo.Status == "stopped",
	}

	// 如果有正在播放的文件，添加文件信息
	if playbackInfo.Source != nil {
		response["currentFile"] = gin.H{
			"name":   playbackInfo.Source.Name,
			"format": playbackInfo.Source.Format,
			"path":   playbackInfo.Source.Path,
		}
	}

	c.JSON(http.StatusOK, response)
}

// HandlePlaylistsList 获取所有播放列表
func (h *Handler) HandlePlaylistsList(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取所有播放列表
	playlists, err := h.AudioManager.playlistManager.ListPlaylists()
	if err != nil {
		logger.SystemError("获取播放列表列表失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("获取播放列表失败: %v", err),
		})
		return
	}

	// 获取默认播放列表
	defaultPlaylist, err := h.AudioManager.playlistManager.GetDefaultPlaylist()
	var defaultID string
	if err == nil && defaultPlaylist != nil {
		defaultID = defaultPlaylist.ID
	}

	c.JSON(http.StatusOK, gin.H{
		"success":   true,
		"playlists": playlists,
		"defaultID": defaultID,
		"total":     len(playlists),
	})
}

// HandlePlaylistCreate 创建新的播放列表
func (h *Handler) HandlePlaylistCreate(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 解析请求数据
	var request struct {
		Name string `json:"name" binding:"required"`
	}
	if err := c.ShouldBindJSON(&request); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无效的请求数据",
		})
		return
	}

	// 创建播放列表
	playlist, err := h.AudioManager.playlistManager.CreatePlaylist(request.Name)
	if err != nil {
		logger.SystemError("创建播放列表失败", zap.Error(err), zap.String("name", request.Name))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("创建播放列表失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success":  true,
		"message":  "播放列表创建成功",
		"playlist": playlist,
	})
}

// HandleGetPlaylist 获取指定播放列表
func (h *Handler) HandleGetPlaylist(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID
	playlistID := c.Param("id")
	if playlistID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID",
		})
		return
	}

	// 获取播放列表
	playlist, err := h.AudioManager.playlistManager.GetPlaylist(playlistID)
	if err != nil {
		logger.SystemError("获取播放列表失败", zap.Error(err), zap.String("id", playlistID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("获取播放列表失败: %v", err),
		})
		return
	}

	if playlist == nil {
		c.JSON(http.StatusNotFound, gin.H{
			"success": false,
			"error":   "播放列表不存在",
		})
		return
	}

	// 检查是否为默认播放列表
	defaultPlaylist, _ := h.AudioManager.playlistManager.GetDefaultPlaylist()
	isDefault := defaultPlaylist != nil && defaultPlaylist.ID == playlistID

	c.JSON(http.StatusOK, gin.H{
		"success":   true,
		"playlist":  playlist,
		"isDefault": isDefault,
	})
}

// HandleUpdatePlaylist 更新播放列表
func (h *Handler) HandleUpdatePlaylist(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID
	playlistID := c.Param("id")
	if playlistID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID",
		})
		return
	}

	// 解析请求数据
	var playlist playlist.Playlist
	if err := c.ShouldBindJSON(&playlist); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无效的请求数据",
		})
		return
	}

	// 确保ID一致
	if playlist.ID != playlistID {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "播放列表ID不一致",
		})
		return
	}

	// 更新播放列表
	if err := h.AudioManager.playlistManager.UpdatePlaylist(&playlist); err != nil {
		logger.SystemError("更新播放列表失败", zap.Error(err), zap.String("id", playlistID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("更新播放列表失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "播放列表更新成功",
	})
}

// HandleDeletePlaylist 删除播放列表
func (h *Handler) HandleDeletePlaylist(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID
	playlistID := c.Param("id")
	if playlistID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID",
		})
		return
	}

	// 检查是否为默认播放列表
	defaultPlaylist, _ := h.AudioManager.playlistManager.GetDefaultPlaylist()
	if defaultPlaylist != nil && defaultPlaylist.ID == playlistID {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无法删除默认播放列表",
		})
		return
	}

	// 删除播放列表
	if err := h.AudioManager.playlistManager.DeletePlaylist(playlistID); err != nil {
		logger.SystemError("删除播放列表失败", zap.Error(err), zap.String("id", playlistID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("删除播放列表失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "播放列表删除成功",
	})
}

// HandleSetDefaultPlaylist 设置默认播放列表
func (h *Handler) HandleSetDefaultPlaylist(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID
	playlistID := c.Param("id")
	if playlistID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID",
		})
		return
	}

	// 设置默认播放列表
	if err := h.AudioManager.playlistManager.SetDefaultPlaylist(playlistID); err != nil {
		logger.SystemError("设置默认播放列表失败", zap.Error(err), zap.String("id", playlistID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("设置默认播放列表失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "默认播放列表设置成功",
	})
}

// HandlePlaylistAddItem 向播放列表添加项目
func (h *Handler) HandlePlaylistAddItem(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID
	playlistID := c.Param("id")
	if playlistID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID",
		})
		return
	}

	// 解析请求数据
	var item playlist.PlaylistItem
	if err := c.ShouldBindJSON(&item); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "无效的请求数据",
		})
		return
	}

	// 添加项目到播放列表
	if err := h.AudioManager.playlistManager.AddItem(playlistID, item); err != nil {
		logger.SystemError("向播放列表添加项目失败", zap.Error(err), zap.String("playlistID", playlistID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("向播放列表添加项目失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "项目添加成功",
		"item":    item,
	})
}

// HandlePlaylistRemoveItem 从播放列表移除项目
func (h *Handler) HandlePlaylistRemoveItem(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID和项目ID
	playlistID := c.Param("id")
	itemID := c.Param("itemId")
	if playlistID == "" || itemID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID或项目ID",
		})
		return
	}

	// 从播放列表移除项目
	if err := h.AudioManager.playlistManager.RemoveItem(playlistID, itemID); err != nil {
		logger.SystemError("从播放列表移除项目失败", zap.Error(err), zap.String("playlistID", playlistID), zap.String("itemID", itemID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("从播放列表移除项目失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "项目移除成功",
	})
}

// HandlePlaylistClear 清空播放列表
func (h *Handler) HandlePlaylistClear(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID
	playlistID := c.Param("id")
	if playlistID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID",
		})
		return
	}

	// 清空播放列表
	if err := h.AudioManager.playlistManager.ClearPlaylist(playlistID); err != nil {
		logger.SystemError("清空播放列表失败", zap.Error(err), zap.String("playlistID", playlistID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("清空播放列表失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "播放列表已清空",
	})
}

// HandleLoadPlaylist 加载播放列表到播放器
func (h *Handler) HandleLoadPlaylist(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取播放列表ID
	playlistID := c.Param("id")
	if playlistID == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"error":   "未指定播放列表ID",
		})
		return
	}

	// 同步到播放器
	if err := h.AudioManager.playlistManager.SyncToPlayer(playlistID); err != nil {
		logger.SystemError("加载播放列表到播放器失败", zap.Error(err), zap.String("playlistID", playlistID))
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   fmt.Sprintf("加载播放列表到播放器失败: %v", err),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "播放列表已加载到播放器",
	})
}

// HandleGetDefaultPlaylist 获取默认播放列表
func (h *Handler) HandleGetDefaultPlaylist(c *gin.Context) {
	// 检查播放列表管理器是否初始化
	if h.AudioManager.playlistManager == nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"success": false,
			"error":   "播放列表管理器未初始化",
		})
		return
	}

	// 获取默认播放列表
	playlist, err := h.AudioManager.playlistManager.GetDefaultPlaylist()
	if err != nil {
		logger.SystemError("获取默认播放列表失败", zap.Error(err))

		// 如果是因为默认播放列表未设置，则创建一个新的默认播放列表
		if err.Error() == "没有设置默认播放列表" {
			newPlaylist, createErr := h.AudioManager.playlistManager.CreatePlaylist("默认播放列表")
			if createErr != nil {
				logger.SystemError("创建默认播放列表失败", zap.Error(createErr))
				c.JSON(http.StatusInternalServerError, gin.H{
					"success": false,
					"error":   fmt.Sprintf("创建默认播放列表失败: %v", createErr),
				})
				return
			}

			// 设置为默认播放列表
			if setErr := h.AudioManager.playlistManager.SetDefaultPlaylist(newPlaylist.ID); setErr != nil {
				logger.SystemError("设置默认播放列表失败", zap.Error(setErr))
				c.JSON(http.StatusInternalServerError, gin.H{
					"success": false,
					"error":   fmt.Sprintf("设置默认播放列表失败: %v", setErr),
				})
				return
			}

			// 返回新创建的播放列表
			playlist = newPlaylist
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{
				"success": false,
				"error":   fmt.Sprintf("获取默认播放列表失败: %v", err),
			})
			return
		}
	}

	c.JSON(http.StatusOK, gin.H{
		"success":  true,
		"playlist": playlist,
	})
}
